﻿#define _CRT_SECURE_NO_WARNINGS 1、
#include<stdio.h>
int main()
{
	char a[100] = "\0";
	gets(a);
	return 0;
}
//小区便利店正在促销，用 numExchange 个空酒瓶可以兑换一瓶新酒。你购入了 numBottles 瓶酒。
//
//如果喝掉了酒瓶中的酒，那么酒瓶就会变成空的。
//
//请你计算 最多 能喝到多少瓶酒。
//
//来源：力扣（LeetCode）
//链接：https://leetcode-cn.com/problems/water-bottles
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int numWaterBottles(int numBottles, int numExchange){
//	int sum = numBottles;
//	while (numBottles >= numExchange)
//	{
//		sum += numBottles / numExchange;
//		numBottles = numBottles / numExchange + numBottles%numExchange;
//	}
//	return sum;
//}








//
//如果数组是单调递增或单调递减的，那么它是单调的。
//
//如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。
//
//当给定的数组 A 是单调数组时返回 true，否则返回 false。
//bool isMonotonic(int* nums, int numsSize){
//	int count = 0;
//	int count1 = 0;
//	for (int i = 0; i<numsSize - 1; i++)
//	{
//		if (nums[i] <= nums[i + 1])
//		{
//			count++;
//		}
//		if (nums[i] >= nums[i + 1])
//		{
//			count1++;
//		}
//	}
//	if (count1 == numsSize - 1 || count == numsSize - 1)
//	{
//		return true;
//	}
//	return false;
//}









//给定一个正整数 n，找到并返回 n 的二进制表示中两个 相邻 1 之间的 最长距离 。如果不存在两个相邻的 1，返回 0 。
//
//如果只有 0 将两个 1 分隔开（可能不存在 0 ），则认为这两个 1 彼此 相邻 。两个 1 之间的距离是它们的二进制表示中位置的绝对差。例如，"1001" 中的两个 1 的距离为 3 。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/binary-gap
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int binaryGap(int n){
//	int count = 0;
//	int dist = 0;
//	int res = 0;
//	while (n>0)
//	{
//		if (n & 1 == 1)
//		{
//			count++;
//			if (count == 2)
//			{
//				res = fmax(res, dist);
//				dist = 1;
//				count = 1;
//			}
//			else
//			{
//				dist++;
//			}
//		}
//		else if (count == 1)
//		{
//
//			dist++;
//		}
//		n >>= 1;
//	}
//	return res;
//}	







/**
爱丽丝和鲍勃有不同大小的糖果棒：A[i] 是爱丽丝拥有的第 i 根糖果棒的大小，B[j] 是鲍勃拥有的第 j 根糖果棒的大小。

因为他们是朋友，所以他们想交换一根糖果棒，这样交换后，他们都有相同的糖果总量。（一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。）

返回一个整数数组 ans，其中 ans[0] 是爱丽丝必须交换的糖果棒的大小，ans[1] 是 Bob 必须交换的糖果棒的大小。

如果有多个答案，你可以返回其中任何一个。保证答案存在。

 
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* fairCandySwap(int* aliceSizes, int aliceSizesSize, int* bobSizes, int bobSizesSize, int* returnSize){
//	int*ret = (int*)malloc(sizeof(int) * 2);
//	*returnSize = 2;
//	int suma = 0;
//	int i = 0;
//	for (i = 0; i<aliceSizesSize; i++)
//	{
//		suma += aliceSizes[i];
//	}
//	int sumb = 0;
//	for (i = 0; i<bobSizesSize; i++)
//	{
//		sumb += bobSizes[i];
//	}
//	int count = (suma - sumb) / 2;
//	int x = -1, y = -1;
//	int b = 0;
//	for (i = 0; i<aliceSizesSize&&!b; i++)
//	{
//		x = aliceSizes[i];
//		for (int j = 0; j<bobSizesSize; j++)
//		{
//			y = bobSizes[j];
//			if (x - y == count)
//			{
//				b = 1;
//				break;
//			}
//		}
//	}
//	ret[0] = x;
//	ret[1] = y;
//	return ret;
//}








/**给你一个字符串 s 和一个字符 c ，且 c 是 s 中出现过的字符。

返回一个整数数组 answer ，其中 answer.length == s.length 且 answer[i] 是 s 中从下标 i 到离它 最近 的字符 c 的 距离 。

两个下标 i 和 j 之间的 距离 为 abs(i - j) ，其中 abs 是绝对值函数

来源：力扣（LeetCode）
//链接：https://leetcode-cn.com/problems/shortest-distance-to-a-character
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* shortestToChar(char * s, char c, int* returnSize){
//	int len = strlen(s);
//	int*a = (int*)malloc(sizeof(int)*len);
//	*returnSize = len;
//	int p = -len;
//	for (int i = 0; i<len; i++)
//	{
//		if (s[i] == c)
//		{
//			p = i;
//		}
//		a[i] = i - p;
//	}
//	for (int i = p - 1; i >= 0; i--)
//	{
//		if (s[i] == c)
//		{
//			p = i;
//		}
//		if (a[i]>p - i)
//		{
//			a[i] = p - i;
//		}
//	}
//	return a;
//}








//给定一个由空格分割单词的句子 S。每个单词只包含大写或小写字母。
//
//我们要将句子转换为 “Goat Latin”（一种类似于 猪拉丁文  - Pig Latin 的虚构语言）。
//
//山羊拉丁文的规则如下：
//
//如果单词以元音开头（a, e, i, o, u），在单词后添加"ma"。
//例如，单词"apple"变为"applema"。
//
//如果单词以辅音字母开头（即非元音字母），移除第一个字符并将它放到末尾，之后再添加"ma"。
//例如，单词"goat"变为"oatgma"。
//
//根据单词在句子中的索引，在单词最后添加与索引相同数量的字母'a'，索引从1开始。
//例如，在第一个单词后添加"a"，在第二个单词后添加"aa"，以此类推。
//返回将 S 转换为山羊拉丁文后的句子。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/goat-latin
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//char * toGoatLatin(char * sentence){
//	int len = strlen(sentence);
//	char*a = (char*)malloc(sizeof(char) * 1500);
//	int count = 0;
//	int index = 0;
//	int tab = -1;
//	for (int i = 0; i<len; i++)
//	{
//		if (sentence[i] == ' ' || i == len - 1)
//		{
//			if (i == len - 1)
//			{
//				i = len;
//			}
//			if (sentence[tab + 1] == 'a' ||
//				sentence[tab + 1] == 'A' ||
//				sentence[tab + 1] == 'e' ||
//				sentence[tab + 1] == 'E' ||
//				sentence[tab + 1] == 'i' ||
//				sentence[tab + 1] == 'I' ||
//				sentence[tab + 1] == 'o' ||
//				sentence[tab + 1] == 'O' ||
//				sentence[tab + 1] == 'u' ||
//				sentence[tab + 1] == 'U')
//			{
//				while (tab<i - 1)
//				{
//					a[index++] = sentence[++tab];
//				}
//				tab++;
//			}
//			else
//			{
//				char c = sentence[++tab];
//				while (tab<i - 1)
//				{
//					a[index++] = sentence[++tab];
//				}
//				a[index++] = c;
//				tab++;
//			}
//			a[index++] = 'm';
//			a[index++] = 'a';
//			count++;
//			int j = 0;
//			while (j<count)
//			{
//				a[index++] = 'a';
//				j++;
//			}
//			if (i != len - 1)
//			{
//				a[index++] = ' ';
//			}
//		}
//	}
//	a[--index] = '\0';
//	return a;
//}







//给定包含多个点的集合，从其中取三个点组成三角形，返回能组成的最大三角形的面积。
//double largestTriangleArea(int** points, int pointsSize, int* pointsColSize){
//	double a = 0, b;
//	int i, j, k;
//	for (i = 0; i<pointsSize - 2; i++)
//	{
//		for (j = i + 1; j<pointsSize - 1; j++)
//		{
//			for (k = j + 1; k<pointsSize; k++)
//			{
//				if ((points[i][0] - points[j][0])
//					*(points[j][1] - points[k][1])
//					!= (points[i][1] - points[j][1])
//					*(points[j][0] - points[k][0]))
//				{
//					b = abs(points[i][0] *
//						points[j][1] + 
//						points[i][1] * 
//						points[k][0] + 
//						points[j][0] * 
//						points[k][1] - 
//						points[i][0] * 
//						points[k][1] - 
//						points[i][1] * 
//						points[j][0] - 
//						points[j][1] * 
//						points[k][0]) / 2.0;
//					a = a>b ? a : b;
//				}
//			}
//		}
//	}
//	return a;
//}








//给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
//bool whil(char* s, int l, int r)
//{
//	while (l<r)
//	{
//		if (s[l] != s[r])
//		{
//			return false;
//		}
//		l++;
//		r--;
//	}
//	return true;
//}
//bool validPalindrome(char * s){
//	int l = 0;
//	int r = strlen(s) - 1;
//	while (l<r)
//	{
//		if (s[l] != s[r])
//		{
//			return whil(s, l + 1, r) || whil(s, l, r - 1);
//		}
//		l++;
//		r--;
//	}
//	return true;
//}








//给定 n 个整数，找出平均数最大且长度为 k 的连续子数组，并输出该最大平均数。
//double findMaxAverage(int* nums, int numsSize, int k){
//	int sum = 0;
//	for (int i = 0; i<k; i++)
//	{
//		sum += nums[i];
//	}
//	int summax = sum;
//	for (int i = k; i<numsSize; i++)
//	{
//		sum = sum - nums[i - k] + nums[i];
//		summax = fmax(sum, summax);
//	}
//	return (double)(summax) / k;
//}







//给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积。
//int cmp(void* a, void* b)
//{
//	return *(int*)a - *(int*)b;
//}
//int maximumProduct(int* nums, int numsSize){
//	qsort(nums, numsSize, sizeof(int), cmp);
//	int count = fmax(nums[0] * nums[1] * nums[numsSize - 1], nums[numsSize - 1] * nums[numsSize - 2] * nums[numsSize - 3]);
//	return count;
//}






	

//给定一个初始元素全部为 0，大小为 m*n 的矩阵 M 以及在 M 上的一系列更新操作。
//
//操作用二维数组表示，其中的每个操作用一个含有两个正整数 a 和 b 的数组表示，含义是将所有符合 0 <= i < a 以及 0 <= j < b 的元素 M[i][j] 的值都增加 1。
//
//在执行给定的一系列操作后，你需要返回矩阵中含有最大整数的元素个数。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/range-addition-ii
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int maxCount(int m, int n, int** ops, int opsSize, int* opsColSize){
//	int min = m;
//	int min1 = n;
//	for (int i = 0; i<opsSize; i++)
//	{
//		if (ops[i][0]<min)
//		{
//			min = ops[i][0];
//		}
//		if (ops[i][1]<min1)
//		{
//			min1 = ops[i][1];
//		}
//	}
//	return min1*min;
//}